package GUI;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

import Logica.Ganador;

public class TableroGUI extends Canvas {

	/**
	 * 
	 */
	private static final long serialVersionUID = 5098518918367250392L;

	private Polygon MatrizPoligonos[][];
	private int jugadas[][];

	public int tamX;
	public int tamY;
	private int tamanio;
	private int tamLinea = 20;
	@SuppressWarnings("unused")
	private int jugador = 1;
	private boolean ganador;
	int jugadaActualX;
	int jugadaActualY;
	int jugadaAnteriorX;
	int jugadaAnteriorY;
	
	public TableroGUI(int tamanio) {
		this.tamanio = tamanio;
		this.MatrizPoligonos = new Polygon[tamanio][tamanio];
		this.jugadas = new int[tamanio][tamanio];
		tamX = (2 * tamLinea * tamanio) + (tamLinea * (tamanio - 1));
		tamY = tamLinea * tamanio * 2 + 1;
		cacularPoligonosTablero();
        jugadaAnteriorX = -1;
        jugadaAnteriorY = -1;
	}

	private void cacularPoligonosTablero() {

		int inicioX = 0;
		int inicioY = tamY / 2;
		int inicioSiguienteLineaX = inicioX;
		int inicioSiguienteLineaY = inicioY;
		int inicioSiguienteX = inicioX;
		int inicioSiguienteY = inicioY;

		for (int i = 0; i < tamanio; i++) {
			if (i > 0) {
				inicioSiguienteLineaX = inicioSiguienteLineaX + tamLinea
						+ tamLinea / 2;
				inicioSiguienteLineaY = inicioSiguienteLineaY + tamLinea;
				inicioSiguienteX = inicioSiguienteLineaX;
				inicioSiguienteY = inicioSiguienteLineaY;

			}

			for (int j = 0; j < tamanio; j++) {

				inicioX = inicioSiguienteX;
				inicioY = inicioSiguienteY;
				int[] puntosX = new int[] { inicioX, inicioX + tamLinea / 2,
						(inicioSiguienteX = inicioX + tamLinea / 2 + tamLinea),
						inicioX + 2 * tamLinea,
						inicioX + tamLinea / 2 + tamLinea,
						inicioX + tamLinea / 2, inicioX

				};
				int[] puntosY = new int[] { inicioY, inicioY - tamLinea,
						(inicioSiguienteY = inicioY - tamLinea), inicioY,
						inicioY + tamLinea, inicioY + tamLinea, inicioY };

				Polygon p = new Polygon(puntosX, puntosY, puntosX.length);

				this.MatrizPoligonos[i][j] = p;

			}
		}
	}

	@Override
	public void paint(Graphics g) {
		this.setSize(new Dimension(tamX, tamY));
		super.paint(g);
		g.setColor(Color.GREEN);
		g.drawLine(0, 0, tamX / 2, 0);
		g.drawLine(0, 0, 0, tamY / 2);
		g.drawLine(tamX - 1, tamY - 1, tamX / 2, tamY - 1);
		g.drawLine(tamX - 1, tamY - 1, tamX - 1, tamY / 2);
		g.setColor(Color.BLUE);
		g.drawLine(tamX / 2, 0, tamX, 0);
		g.drawLine(tamX - 1, 0, tamX - 1, tamY / 2);
		g.drawLine(0, tamY / 2, 0, tamY - 1);
		g.drawLine(0, tamY - 1, tamX / 2, tamY - 1);

		g.setColor(Color.BLACK);

		for (int i = 0; i < tamanio; i++) {
			for (int j = 0; j < tamanio; j++) {

				if (jugadas[i][j] == 1 || jugadas[i][j] == 3) {
					g.setColor(Color.green);

				} else if (jugadas[i][j] == 2) {
					g.setColor(Color.blue);

				} else {
					g.setColor(Color.GRAY);

				}
				g.fillPolygon(MatrizPoligonos[i][j]);
				g.setColor(Color.black);
				g.drawPolygon(MatrizPoligonos[i][j]);

			}
		}

	}

	public boolean realizarJugada(Point p, int Jugador) {
		boolean realizaJugada = true;
		this.jugador = Jugador;
		gral: for (int i = 0; i < tamanio; i++) {
			for (int j = 0; j < tamanio; j++) {
				if (MatrizPoligonos[i][j].contains(p)) {
					if (jugadas[i][j] == 0) {
						jugadaActualX = i;
						jugadaActualY = j;
						jugadas[i][j] = Jugador;
						ganador = new Ganador().hayGanador(jugadas, tamanio,
								Jugador);
					} else {
						realizaJugada = false;
					}

					break gral;
				}
			}
		}
		this.repaint();
		return realizaJugada;
	}

	public boolean realizarJugadaVirtual(int Jugador) {
		boolean realizaJugada = true;
		this.jugador = Jugador;
		jugadas = calcularJugada(jugadas, jugadaAnteriorX, jugadaAnteriorY);
		this.repaint();
		return realizaJugada;
	}

	public String jugadaActual() {
		String ja = jugadas[jugadaActualX][jugadaActualY] == 3 ? "COM"
				: jugadas[jugadaActualX][jugadaActualY] + "";

		return "Jugador " + ja + ": (" + jugadaActualX + "," + jugadaActualY
				+ ")";
	}

	public boolean hayGanador() {
		return ganador;
	}

	public int[][] calcularJugada(int[][] jugadas, int x, int y) {
		if(jugadaAnteriorX == -1 && jugadaAnteriorY == -1 ){
			jugadas[tamanio/2][tamanio/2] = 3;
			jugadaAnteriorX = tamanio/2 ;
			jugadaAnteriorY = tamanio/2;
		}else if (x>0 && jugadas[x - 1][y] == 0) {
			jugadas[x - 1][y] = 3;
			jugadaAnteriorX = x + 1;
			jugadaAnteriorY = y - 1;
		} else if (x-1>=0 && y+1<jugadas[0].length && jugadas[x - 1][y + 1] == 0) {
			jugadas[x - 1][y + 1] = 3;
			jugadaAnteriorX = x;
			jugadaAnteriorY = y-1;
		} else if (x+1 < jugadas.length && jugadas[x + 1][y] == 0) {
			jugadas[x + 1][y] = 3;
			jugadaAnteriorX = x;
			jugadaAnteriorY = y +1;
		} else if (x+1<jugadas.length && y-1>=0 && jugadas[x + 1][y - 1] == 0) {
			jugadas[x + 1][y - 1] = 3;
			jugadaAnteriorX = x-1 ;
			jugadaAnteriorY = y + 1; 
		} else{
			boolean jugadaRandom = false;
			while(!jugadaRandom){
				int []psr = posicionAleatoria(tamanio);
				if(jugadas[psr[0]][psr[1]] == 0){
					jugadas[psr[0]][psr[1]] = 3;
					jugadaAnteriorX = psr[0];
					jugadaAnteriorY = psr[1];
					jugadaRandom = true;
				}
			}
		}
		
		return jugadas;
	}

	private int[] posicionAleatoria(int n) {
		ArrayList<Integer> arr = new ArrayList<Integer>();
		for (int i = 0; i < n; i++) {
			arr.add(i);
		}
		Collections.shuffle(arr);
		
		return new int[]{arr.get(0), arr.get(1)};
	}

}